Problem:- You will be predicting the costs of used cars given the data collected from various sources and distributed across various locations in India.¶
FEATURES:¶
Name: The brand and model of the car.
Location: The location in which the car is being sold or is available for purchase.
Year: The year or edition of the model.
Kilometers_Driven: The total kilometres driven in the car by the previous owner(s) in KM.
Fuel_Type: The type of fuel used by the car.
Transmission: The type of transmission used by the car.
Owner_Type: Whether the ownership is Firsthand, Second hand or other.
Mileage: The standard mileage offered by the car company in kmpl or km/kg
Engine: The displacement volume of the engine in cc.
Power: The maximum power of the engine in bhp.
Seats: The number of seats in the car.
New_Price: The price of a new car of the same model.
Price: The price of the used car in INR Lakhs.
Importing Libraries¶
In [1]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.linear_model import Lasso
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.model_selection import KFold, cross_val_score, train_test_split
from sklearn.metrics import mean_squared_error
import xgboost as xgb
import lightgbm as lgb
from sklearn.neighbors import KNeighborsClassifier
from sklearn import model_selection
from sklearn.preprocessing import MinMaxScaler
import warnings
warnings.filterwarnings("ignore")
Data Collection¶
In [2]:
Train=pd.read_excel('Data_Train.xlsx')
Test=pd.read_excel('Data_Test.xlsx')
In [3]:
Train.head()
Out[3]:
In [5]:
Test.shape ,Train.shape
Out[5]:
In [6]:
Train.duplicated().sum()
Out[6]:
In [7]:
Test_copy=Test.copy()
Data Cleaning & Imputing Missing Values¶
In [8]:
Test[Test.duplicated()]
Test[Test['Name'].str.contains("Honda City 1.5 E MT")]
Out[8]:
In [9]:
#removing unit of Mileage column
for Unit in ['km/kg','kmpl']:
Train.Mileage = Train.Mileage.str.replace(Unit,' ')
Train.Mileage=Train.Mileage.astype(float)
#creating new columns
Train['Mileage_per_kg']=[0.0 for i in range(len(Train.Mileage))]
Train['Mileage_per_l']=[0.0 for i in range(len(Train.Mileage))]
Train
for i in range(len(Train)):
if (Train['Fuel_Type'][i]=='CNG'):
Train['Mileage_per_kg'][i]=Train['Mileage'][i]
if (Train['Fuel_Type'][i]=='LPG'):
Train['Mileage_per_kg'][i]=Train['Mileage'][i]
if (Train['Fuel_Type'][i]=='Petrol'):
Train['Mileage_per_l'][i]=Train['Mileage'][i]
if (Train['Fuel_Type'][i]=='Diesel'):
Train['Mileage_per_l'][i]=Train['Mileage'][i]
if (Train['Fuel_Type'][i]=='Electric'):
Train['Mileage_per_l'][i]=0
Train['Mileage_per_kg'][i]=0
Train['Mileage_per_kg']=Train['Mileage_per_kg'].astype(float)
Train['Mileage_per_l']=Train['Mileage_per_l'].astype(float)
Train
Out[9]:
In [10]:
Train['Fuel_Type'].unique()
Test['Fuel_Type'].unique()
Test.info()
In [11]:
#removing unit of Mileage column in test data
for Unit in ['km/kg','kmpl']:
Test.Mileage = Test.Mileage.str.replace(Unit,' ')
Test.Mileage=Test.Mileage.astype(float)
Test
#creating new columns in test data
Test['Mileage_per_kg']=[0.0 for i in range(len(Test.Mileage))]
Test['Mileage_per_l']=[0.0 for i in range(len(Test.Mileage))]
Test
for i in range(len(Test)):
if (Test['Fuel_Type'][i]=='CNG'):
Test['Mileage_per_kg'][i]=Test['Mileage'][i]
if (Test['Fuel_Type'][i]=='LPG'):
Test['Mileage_per_kg'][i]=Test['Mileage'][i]
if (Test['Fuel_Type'][i]=='Petrol'):
Test['Mileage_per_l'][i]=Test['Mileage'][i]
if (Test['Fuel_Type'][i]=='Diesel'):
Test['Mileage_per_l'][i]=Test['Mileage'][i]
if (Test['Fuel_Type'][i]=='Electric'):
Test['Mileage_per_l'][i]=0
Test['Mileage_per_kg'][i]=0
Test['Mileage_per_kg']=Test['Mileage_per_kg'].astype(float)
Test['Mileage_per_l']=Test['Mileage_per_l'].astype(float)
Test
Out[11]:
In [12]:
#removing units from Mileage,Power,Engine
Train['Engine']=Train['Engine'].str.strip('CC')
Train['Power']=Train['Power'].str.strip('bhp')
Train
Out[12]:
In [13]:
Test
Out[13]:
In [14]:
#removing Units from Test data
Test['Engine']=Test['Engine'].str.strip('CC')
Test['Power']=Test['Power'].str.strip('bhp')
Test
Out[14]:
In [15]:
#Spliting Name
Train['Brand']=Train['Name'].str.split(' ').str[0]
Train['Model']=Train['Name'].str.split(' ').str[1]
Train['Version']=Train['Name'].str.split(' ').str[2:7].str.join(" ")
Train
Out[15]:
In [16]:
#Spliting Name in Test Data
Test['Brand']=Test['Name'].str.split(' ').str[0]
Test['Model']=Test['Name'].str.split(' ').str[1]
Test['Version']=Test['Name'].str.split(' ').str[2:7].str.join(" ")
Test
Out[16]:
Dealing with null/missing values
In [17]:
Train.info()
In [18]:
Test.info()
In [19]:
Train.isnull().sum()
Out[19]:
In [20]:
#Imputing Null Values in Power
for i in range(len(Train)):
if (Train['Power'][i]=='null '):
Train['Power'][i]=0.0
Train['Power']=Train['Power'].astype(float)
for i in range(len(Test)):
if (Test['Power'][i]=='null '):
Test['Power'][i]=0.0
Test['Power']=Test['Power'].astype(float)
In [21]:
#set of columns which contains null values
Null_column_Train = ["Mileage","Engine","Power","Seats"]
Null_column_Test = ["Engine","Power","Seats"]
In [22]:
# Defining a function for Replacing null values
def Null_replacing_Fun(dataset , Null_column):
for i in range(len(Null_column)):
dataset[Null_column[i]].fillna(dataset[Null_column[i]].mode()[0] , inplace = True)
print(dataset)
In [23]:
#calling funtion to null replacing for Train Data
Null_replacing_Fun(Train , Null_column_Train)
In [24]:
Train.info()
In [25]:
Train.isnull().sum()
Out[25]:
In [26]:
#calling function for Test data set
Null_replacing_Fun(Test , Null_column_Test)
In [27]:
Test.isnull().sum()
Out[27]:
In [28]:
Test.info()
In [29]:
Test
Out[29]:
In [30]:
Test.head()
Out[30]:
In [31]:
#creating Age of car column
Train['Age']=2020-Train['Year']
Train
Out[31]:
In [32]:
#creating Age of car column
Test['Age']=2020-Test['Year']
Test
Out[32]:
In [33]:
Train['Name'].unique()
Out[33]:
In [34]:
Test['Name'].unique()
Out[34]:
In [35]:
Train[Train['Mileage'].isnull()]
Out[35]:
In [36]:
Train[Train['Power'].isnull()]
Out[36]:
In [37]:
Train['Name'].value_counts()
Out[37]:
In [38]:
Test['Name'].value_counts()
Out[38]:
EDA And Visualization¶
Droping outliners¶
In [39]:
#removing outliners
print(Train[Train['Seats']<2])
Train.drop(Train[Train['Seats']<2].index,inplace= True)
Train[Train['Seats']<2]
Out[39]:
In [40]:
Train[Train['Price']>100]
Out[40]:
In [41]:
#Droping Outliners
Train=Train.drop(Train[Train['Price']>100].index)
Train.info()
In [42]:
Train.describe()
Out[42]:
In [43]:
Train[Train['Kilometers_Driven']>800000]
Out[43]:
In [44]:
Train=Train.drop(Train[Train['Kilometers_Driven']>800000].index)
In [45]:
Train['Year'].value_counts().plot.bar()
Out[45]:
In [46]:
Train['Fuel_Type'].value_counts().plot.bar()
Out[46]:
In [47]:
Train['Owner_Type'].value_counts().plot.bar()
Out[47]:
In [48]:
Train['Location'].value_counts().plot.bar()
Out[48]:
In [49]:
Train.Price.sort_values(ascending=False)
Out[49]:
In [50]:
Train.Price.mean()
Out[50]:
In [51]:
Train[Train.Price>9.47]
Out[51]:
In [52]:
Train.Mileage.sort_values()
Out[52]:
In [53]:
pd.crosstab(Train.Location, Train.Owner_Type)
Out[53]:
In [54]:
Train['Location'].value_counts(normalize=True)
Out[54]:
Plots¶
In [55]:
sns.distplot(Train["Year"])
Out[55]:
In [56]:
sns.distplot(Train["Price"])
Out[56]:
In [57]:
plt.figure(figsize=(20,5))
sns.boxplot(
data=Train,
x='Fuel_Type',y='Price',
)
Out[57]:
In [58]:
#Price of car vs Locations
plt.figure(figsize=(15,10))
sns.boxplot(x=Train['Location'],y=Train['Price'],data=Train,hue=Train['Fuel_Type'])
Out[58]:
In [59]:
#No. of cars from different Brands
plt.figure(figsize = (12, 8))
plot = sns.countplot(x = 'Brand', data = Train)
plt.xticks(rotation = 90)
for p in plot.patches:
plot.annotate(p.get_height(),
(p.get_x() + p.get_width() / 2.0,
p.get_height()),
ha = 'center',
va = 'center',
xytext = (0, 5),
textcoords = 'offset points')
plt.title("Count of cars based on Brands")
plt.xlabel("Car Brand")
plt.ylabel("Count of cars")
Out[59]:
In [60]:
plt.figure(figsize=(20,5))
sns.boxplot(
data=Train,
x='Transmission',y='Price',
)
Out[60]:
In [61]:
plt.figure(figsize=(20,5))
sns.boxplot(
data=Train,
x='Owner_Type',y='Price',
color='red')
Out[61]:
In [62]:
plt.figure(figsize=(20,5))
sns.boxplot(
data=Train,
x='Location',y='Price',
color='red')
Out[62]:
In [63]:
sns.jointplot(x='Price',y='Kilometers_Driven',data=Train,kind='hex')
Out[63]:
In [64]:
sns.set(style="white", palette="muted", color_codes=True)
Train['Year'].hist(bins=30)
Out[64]:
In [65]:
Train['Mileage'].hist(bins=30)
Out[65]:
In [66]:
sns.violinplot(y='Price',data=Train)
Out[66]:
In [67]:
sns.boxplot(y='Kilometers_Driven',data=Train)
Out[67]:
In [68]:
sns.jointplot(x='Price',y='Kilometers_Driven',data=Train)
Out[68]:
In [69]:
print("Minimum year in the data is:",Train.Year.min())
print("Maximum year in the data is:",Train.Year.max())
print("Range of year is from {} to {},value is{}".format(Train.Year.max(),Train.Year.min(),Train.Year.max()-Train.Year.min()))
print("Default bin is 50,so each bar corresponds to the value of:",(Train.Year.max()-Train.Year.min())/50)
In [70]:
plt.figure(figsize=(20,10))
sns.barplot(x="Engine",y="Price",data=Train)
Out[70]:
In [71]:
plt.figure(figsize=(20,10))
sns.scatterplot(x='Kilometers_Driven',y='Price',data=Train, hue='Brand')
plt.xlim(0, 350000)
Out[71]:
In [72]:
plt.figure(figsize=(20,10))
sns.scatterplot(x='Kilometers_Driven',y='Price',data=Train, hue='Fuel_Type')
plt.xlim(0, 350000)
Out[72]:
In [73]:
plt.figure(figsize=(20,10))
sns.scatterplot(x='Kilometers_Driven',y='Price',data=Train, hue='Location')
plt.xlim(0, 350000)
Out[73]:
In [74]:
plt.figure(figsize=(10,30))
sns.boxplot(
data=Train,
x='Price',y='Brand')
Out[74]:
In [75]:
plt.figure(figsize=(10,5))
sns.boxplot(
data=Train,
x='Kilometers_Driven')
Out[75]:
In [76]:
plt.figure(figsize=(10,10))
sns.boxplot(
data=Train,
x='Price')
Out[76]:
In [77]:
plt.figure(figsize=(10,10))
sns.boxplot(
data=Train,
x='Kilometers_Driven')
Out[77]:
In [78]:
pd.crosstab(Train.Name,Train.Location)
Out[78]:
In [79]:
pd.crosstab(Train.Name,Train.Fuel_Type)
Out[79]:
In [80]:
pd.crosstab(Train.Name, Train.Owner_Type)
Out[80]:
Scaling Data¶
In [81]:
Train.Kilometers_Driven=(Train.Kilometers_Driven-Train.Kilometers_Driven.min())/(Train.Kilometers_Driven.max()-Train.Kilometers_Driven.min())
Train.Kilometers_Driven
Out[81]:
In [82]:
Test.Kilometers_Driven=(Test.Kilometers_Driven-Test.Kilometers_Driven.min())/(Test.Kilometers_Driven.max()-Test.Kilometers_Driven.min())
Test.Kilometers_Driven
Out[82]:
In [83]:
scaler = MinMaxScaler()
num_vars = ['Mileage', 'Power', 'Engine','Mileage_per_kg','Mileage_per_l']
Train[num_vars] = scaler.fit_transform(Train[num_vars])
Train
Out[83]:
In [84]:
scaler = MinMaxScaler()
num_vars = ['Mileage', 'Power', 'Engine','Mileage_per_kg','Mileage_per_l']
Test[num_vars] = scaler.fit_transform(Test[num_vars])
Test
Out[84]:
In [85]:
corrmat = Train.corr()
f, ax = plt.subplots(figsize=(7, 7))
sns.heatmap(corrmat, vmax=.8, square=True);
In [86]:
corr = Train.corr()
sns.heatmap(corr, xticklabels=corr.columns, yticklabels=corr.columns, annot=True, cmap=sns.diverging_palette(220, 20, as_cmap=True))
Out[86]:
In [87]:
sns.lmplot(x='Year', y='Price', data=Train)
Out[87]:
In [88]:
plt.figure(figsize = (10, 6))
sns.boxplot(data=Train)
Out[88]:
In [89]:
Train.boxplot(column=["Age","Seats"])
Out[89]:
In [90]:
Test.info()
In [91]:
sns.boxplot(x=Train['Age'],)
Out[91]:
In [92]:
Train[Train['Seats'].isnull()]
Out[92]:
In [93]:
x = Train['Price']
plt.figure(figsize=(10,6))
sns.distplot(x).set_title('Frequency Distribution Plot of Prices')
Out[93]:
In [94]:
print(Train['Price'].mean())
print(Train['Price'].median())
print(Train['Price'].mode())
Reggression
In [95]:
plt.figure(figsize=(20,8))
sns.regplot(x='Age', y='Price',data=Train).set_title('Age vs Price')
Out[95]:
In [96]:
Train = Train[Train.Kilometers_Driven < 400000]
plt.figure(figsize=(10,6))
sns.regplot(x='Kilometers_Driven', y='Price', data=Train).set_title('Km vs Price')
Out[96]:
In [97]:
plt.figure(figsize=(20,15))
sns.boxplot(data=Train, x='Location',y='Price')
Out[97]:
In [98]:
plt.figure(figsize=(20,10))
sns.boxplot(data=Train,x='Fuel_Type',y='Price')
Out[98]:
In [99]:
plt.figure(figsize=(20,5))
plt.subplot(1,5,1)
x=Train['Location'].value_counts().index
y=Train['Location'].value_counts().values
plt.pie(y,labels=x,autopct='%1.1f%%')
plt.title("Location distribution")
plt.subplot(1,5,2)
x=Train['Owner_Type'].value_counts().index
y=Train['Owner_Type'].value_counts().values
plt.pie(y,labels=x,autopct='%1.1f%%')
plt.title("Owner Type distribution")
plt.subplot(1,5,3)
x=Train['Fuel_Type'].value_counts().index
y=Train['Fuel_Type'].value_counts().values
plt.pie(y,labels=x,autopct='%1.1f%%')
plt.title("Fuel_Type distribution")
plt.subplot(1,5,4)
x=Train['Transmission'].value_counts().index
y=Train['Transmission'].value_counts().values
plt.pie(y,labels=x,autopct='%1.1f%%')
plt.title("Transmission distribution")
plt.subplot(1,5,5)
x=Train['Seats'].value_counts().index
y=Train['Seats'].value_counts().values
plt.pie(y,labels=x,autopct='%1.1f%%')
plt.title("Seats distribution")
Out[99]:
In [100]:
sns.pairplot(Train)
Out[100]:
In [101]:
sns.set(font_scale = 1)
sns.relplot(x = "Year" , y = "Price" , data = Train , hue = "Fuel_Type" ,kind ="line", col = "Owner_Type")
Out[101]:
In [102]:
sns.relplot(x = "Year" , y = "Price" , data = Train , hue = "Fuel_Type" ,
size = "Transmission", sizes=(20,200))
Out[102]:
In [103]:
sns.relplot(x = "Year" , y = "Price" , data = Train , hue = "Owner_Type", kind = "line" )
Out[103]:
Encoding the categorical variables
In [104]:
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder
New_train=Train.copy()
New_test=Test.copy()
New_train= pd.concat([New_train,pd.get_dummies(New_train['Location'], prefix='Location').astype(float)],axis=1)
New_test= pd.concat([New_test,pd.get_dummies(New_test['Location'], prefix='Location').astype(float)],axis=1)
Train
Out[104]:
In [105]:
New_train= pd.concat([New_train,pd.get_dummies(New_train['Brand'], prefix='Br').astype(float)],axis=1)
New_test= pd.concat([New_test,pd.get_dummies(New_test['Brand'], prefix='Br').astype(float)],axis=1)
Train
Out[105]:
In [106]:
lben = LabelEncoder()
New_train['Fuel_Type'] = lben.fit_transform(New_train['Fuel_Type']).astype(float)
New_train['Owner_Type'] = lben.fit_transform(New_train['Owner_Type']).astype(float)
New_train['Transmission'] = lben.fit_transform(New_train['Transmission']).astype(float)
In [107]:
lben = LabelEncoder()
New_test['Fuel_Type'] = lben.fit_transform(New_test['Fuel_Type']).astype(float)
New_test['Owner_Type'] = lben.fit_transform(New_test['Owner_Type']).astype(float)
New_test['Transmission'] = lben.fit_transform(New_test['Transmission']).astype(float)
New_test
Out[107]:
In [108]:
New_train
Out[108]:
In [109]:
New_train=New_train.drop(['Year'],axis=1)
New_test=New_test.drop(['Year'],axis=1)
In [110]:
New_train.corr()
Out[110]:
In [111]:
plt.figure(figsize= (15,10))
Formodel = Train[['Year','Kilometers_Driven','Fuel_Type','Transmission','Owner_Type','Power','Engine','Seats','Age','Mileage_per_l','Mileage_per_kg' ]]
sns.heatmap(Formodel.corr(), annot=True)
Out[111]:
In [112]:
plt.figure(figsize= (20,20))
sns.heatmap(New_train.corr(), annot=True)
Out[112]:
In [113]:
#creating new missing columns in train data
New_train['Br_Hindustan']=[0.0 for row in New_train.index]
New_train['Br_OpelCorsa']=[0.0 for row in New_train.index]
In [114]:
#Rearanging new missing columns in train data
mid = New_test['Br_Hindustan']
New_train.drop(labels=['Br_Hindustan'], axis=1,inplace = True)
New_train.insert(37, 'Br_Hindustan', mid)
mid = New_test['Br_OpelCorsa']
New_train.drop(labels=['Br_OpelCorsa'], axis=1,inplace = True)
New_train.insert(51, 'Br_OpelCorsa', mid)
New_train['Br_Hindustan']=[0.0 for row in New_train.index]
New_train['Br_OpelCorsa']=[0.0 for row in New_train.index]
New_train.info()
In [115]:
#creating missing columns intest data
New_test['Br_Ambassador']=[0.0 for row in New_test.index]
New_test['Br_Force']=[0.0 for i in New_test.index]
In [116]:
#Rearanging new missing columns in train data
mid = New_train['Br_Ambassador']
New_test.drop(labels=['Br_Ambassador'], axis=1,inplace = True)
New_test.insert(27, 'Br_Ambassador', mid)
mid = New_train['Br_Force']
New_test.drop(labels=['Br_Force'], axis=1,inplace = True)
New_test.insert(34, 'Br_Force', mid)
New_test['Br_Ambassador']=[0.0 for row in New_test.index]
New_test['Br_Force']=[0.0 for i in New_test.index]
New_test.info()
In [117]:
X=New_train.drop(['Price','Name','Brand','Location','Model','Version','Mileage',"Br_Smart"],axis=1)
y=New_train['Price']
X['Age']=X['Age'].astype(float)
X['Kilometers_Driven']=X['Kilometers_Driven'].astype(float)
X['Engine']=X['Engine'].astype(float)
X['Power']=X['Power'].astype(float)
X.info()
In [118]:
New_test=New_test.drop(['Name','Brand','Location','Model','Version','Mileage'],axis=1)
New_test['Age']=New_test['Age'].astype(float)
New_test['Kilometers_Driven']=New_test['Kilometers_Driven'].astype(float)
New_test['Engine']=New_test['Engine'].astype(float)
New_test['Power']=New_test['Power'].astype(float)
New_test
Out[118]:
In [119]:
New_test.info()
Model¶
Cross validation
In [120]:
#Function for Predicting accuracy
def Scr(Algo):
scr=Algo.score(X_test,y_test)*100
return (scr)
In [121]:
#k-fold cross-validation
def k_fold(model):
k_folds = model_selection.KFold(n_splits=5, shuffle=False)
scores = model_selection.cross_val_score(model, X_test, y_test, cv=k_folds, scoring='r2')
Avg_Score=np.mean(scores)
return(Avg_Score)
In [122]:
#function for root mean square
def rmsle(y_pred):
return np.sqrt(mean_squared_error(y_test,y_pred))
Splitting Data
In [123]:
#splitting the train-test data for validation
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.20, random_state=123)
In [124]:
X_test.info()
Starting With Linear regresion model
In [125]:
#linear Regression
linreg = LinearRegression()
linreg.fit(X_train, y_train)
Out[125]:
In [126]:
#Predicting the test set results
y_pred_ls = linreg.predict(X_test)
print(linreg.score(X_test, y_test)*100,'% Prediction Accuracy')
GBR Model
In [127]:
#GBR
gbr = GradientBoostingRegressor(loss ='ls', max_depth=6)
gbr.fit (X_train, y_train)
# get the predicted values from the test set
y_pred_gbr= gbr.predict(X_test)
In [128]:
np.sqrt(metrics.mean_squared_error(y_test, y_pred_gbr))
Out[128]:
In [129]:
print(gbr.score(X_test, y_test)*100,'% Prediction Accuracy')
XBG Model
In [130]:
#XGB
model_xgb = xgb.XGBRegressor(colsample_bytree=0.52, gamma=0.03,
learning_rate=0.072, max_depth=6,
min_child_weight=2, n_estimators=2200,
reg_alpha=0, reg_lambda=1,
subsample=0.615, silent=1,
random_state =7, nthread = -1)
In [131]:
model_xgb.fit(X_train,y_train)
xg_t_pre= model_xgb.predict(X_train)
xg_pre=(model_xgb.predict(X_test))
In [132]:
y_predr = model_xgb.predict(X_test)
print(model_xgb.score(X_test, y_test)*100,'% Prediction Accuracy')
Random Forest Model
In [133]:
RF=RandomForestRegressor()
RF.fit(X_train,y_train)
Out[133]:
In [134]:
predic = RF.predict(X_test)
In [135]:
y_pred_RF = RF.predict(X_test)
print(RF.score(X_test, y_test)*100,'% Prediction Accuracy')
Lasso Model
In [136]:
#lasso
ls=Lasso()
ls.fit(X_train,y_train)
Out[136]:
In [137]:
ls_predic = ls.predict(X_test)
In [138]:
print(ls.score(X_test, y_test)*100,'% Prediction Accuracy')
LGB Model
In [139]:
lgb_model = lgb.LGBMRegressor(categorical_feature= [0,2,3,4,8,9,10],task = 'predict',application = 'regression',
objective = 'root_mean_squared_error',boosting_type="gbdt",num_iterations = 2500,
learning_rate = 0.05,num_leaves=15,tree_learner='feature',max_depth =10,min_data_in_leaf=7,
bagging_fraction = 1,bagging_freq = 100,reg_sqrt='True',metric ='rmse',feature_fraction = 0.6,
random_state=42)
lgb_model.fit(X_train,y_train)
Out[139]:
In [140]:
lgb_model_pred = lgb_model.predict(X_test)
In [141]:
print('model ','Score ','rmsle','k-fold' )
print('linreg',round(Scr(linreg),4),round(rmsle(y_pred_ls),4),round(k_fold(linreg),4))
print('gbr ',round(Scr(gbr),4),round(rmsle(y_pred_gbr),4),round(k_fold(gbr),4))
print('xgb ',round(Scr(model_xgb),4),round(rmsle(y_predr),4),round(k_fold(model_xgb),4))
print('RF ',round(Scr(RF),4),round(rmsle(y_pred_RF),4),round(k_fold(RF),4))
print('ls ',round(Scr(ls),4),round(rmsle(ls_predic),4),round(k_fold(ls),4))
print('lgb ',round(Scr(lgb_model),4),round(rmsle(lgb_model_pred),4),round(k_fold(lgb_model),4))
GBR ,RF and LGB are doing good but XGB Seems the best one.
So Using XGB for final Prediction
Final Prediction¶
In [142]:
prediction =model_xgb.predict(New_test)
sol = pd.DataFrame({'Price': prediction })
sol = round(sol['Price'],2)
In [143]:
Test_copy['Prediction']=prediction
Test_copy['Prediction']=Test_copy['Prediction'].round(2)
In [144]:
writer = pd.ExcelWriter('Test_Final.xlsx', engine='xlsxwriter')
Test_copy.to_excel(writer,sheet_name='Sheet1', index=False)
writer.save()
In [145]:
Test_copy.head(50)
Out[145]:
In [ ]:
In [ ]: